#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
日志配置模块 - 统一管理所有模块的日志
支持按日期命名日志文件，存储在log目录中
"""

import logging
import os
import sys
from datetime import datetime
from logging.handlers import RotatingFileHandler
import configparser


class LoggerConfig:
    """日志配置类"""
    
    def __init__(self, config_file="config.ini"):
        """
        初始化日志配置
        :param config_file: 配置文件路径
        """
        # 加载配置文件
        self.config = configparser.ConfigParser()
        self.config.read(config_file, encoding='utf-8')
        
        # 从配置文件读取日志参数
        self.log_level = self.config.get('logging', 'level', fallback='INFO')
        self.log_format = self.config.get('logging', 'format', 
                                         fallback='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        self.log_dir = self.config.get('logging', 'log_dir', fallback='log')
        self.max_file_size = self.config.getint('logging', 'max_file_size', fallback=10)  # MB
        self.backup_count = self.config.getint('logging', 'backup_count', fallback=5)
        self.console_output = self.config.getboolean('logging', 'console_output', fallback=True)
        
        # 创建日志目录
        self._create_log_directory()
        
        # 已配置的logger集合
        self._configured_loggers = set()
    
    def _create_log_directory(self):
        """创建日志目录"""
        if not os.path.exists(self.log_dir):
            os.makedirs(self.log_dir)
            print(f"创建日志目录: {self.log_dir}")
    
    def _get_log_filename(self, module_name=None):
        """
        获取日志文件名
        :param module_name: 模块名称，如果为None则使用通用日志名
        :return: 日志文件路径
        """
        today = datetime.now().strftime("%Y%m%d")
        
        if module_name:
            filename = f"{module_name}_{today}.log"
        else:
            filename = f"vending_{today}.log"
        
        return os.path.join(self.log_dir, filename)
    
    def setup_logger(self, name, module_name=None, level=None):
        """
        设置指定名称的logger
        :param name: logger名称
        :param module_name: 模块名称，用于生成日志文件名
        :param level: 日志级别，如果为None则使用配置文件中的级别
        :return: 配置好的logger对象
        """
        # 如果已经配置过，直接返回
        if name in self._configured_loggers:
            return logging.getLogger(name)
        
        # 创建logger
        logger = logging.getLogger(name)
        
        # 设置日志级别
        if level is None:
            level = getattr(logging, self.log_level.upper(), logging.INFO)
        logger.setLevel(level)
        
        # 清除已有的处理器
        logger.handlers.clear()
        
        # 创建文件处理器
        log_file = self._get_log_filename(module_name)
        file_handler = RotatingFileHandler(
            log_file,
            maxBytes=self.max_file_size * 1024 * 1024,  # 转换为字节
            backupCount=self.backup_count,
            encoding='utf-8'
        )
        file_handler.setLevel(level)
        
        # 创建控制台处理器（如果启用）
        console_handler = None
        if self.console_output:
            console_handler = logging.StreamHandler(sys.stdout)
            console_handler.setLevel(level)
        
        # 创建格式器
        formatter = logging.Formatter(self.log_format)
        file_handler.setFormatter(formatter)
        if console_handler:
            console_handler.setFormatter(formatter)
        
        # 添加处理器到logger
        logger.addHandler(file_handler)
        if console_handler:
            logger.addHandler(console_handler)
        
        # 防止日志向上传播到根logger
        logger.propagate = False
        
        # 记录已配置的logger
        self._configured_loggers.add(name)
        
        logger.info(f"Logger '{name}' 已配置，日志文件: {log_file}")
        return logger
    
    def get_server_logger(self):
        """获取服务器日志器"""
        return self.setup_logger('vending_server', 'server')
    
    def get_client_logger(self):
        """获取客户端日志器"""
        return self.setup_logger('vending_client', 'client')
    
    def get_locker_logger(self):
        """获取电磁锁日志器"""
        return self.setup_logger('vending_locker', 'locker')
    
    def get_camera_logger(self):
        """获取摄像头日志器"""
        return self.setup_logger('vending_camera', 'camera')
    
    def get_general_logger(self):
        """获取通用日志器"""
        return self.setup_logger('vending_general', 'general')
    
    def setup_root_logger(self):
        """设置根日志器"""
        # 获取根logger
        root_logger = logging.getLogger()
        
        # 清除已有的处理器
        root_logger.handlers.clear()
        
        # 设置根logger级别
        level = getattr(logging, self.log_level.upper(), logging.INFO)
        root_logger.setLevel(level)
        
        # 创建文件处理器
        log_file = self._get_log_filename('root')
        file_handler = RotatingFileHandler(
            log_file,
            maxBytes=self.max_file_size * 1024 * 1024,
            backupCount=self.backup_count,
            encoding='utf-8'
        )
        file_handler.setLevel(level)
        
        # 创建控制台处理器（如果启用）
        console_handler = None
        if self.console_output:
            console_handler = logging.StreamHandler(sys.stdout)
            console_handler.setLevel(level)
        
        # 创建格式器
        formatter = logging.Formatter(self.log_format)
        file_handler.setFormatter(formatter)
        if console_handler:
            console_handler.setFormatter(formatter)
        
        # 添加处理器到根logger
        root_logger.addHandler(file_handler)
        if console_handler:
            root_logger.addHandler(console_handler)
        
        root_logger.info(f"根Logger已配置，日志文件: {log_file}")
        return root_logger


# 全局日志配置实例
_logger_config = None


def get_logger_config(config_file="config.ini"):
    """
    获取全局日志配置实例
    :param config_file: 配置文件路径
    :return: LoggerConfig实例
    """
    global _logger_config
    if _logger_config is None:
        _logger_config = LoggerConfig(config_file)
    return _logger_config


def get_server_logger(config_file="config.ini"):
    """获取服务器日志器"""
    return get_logger_config(config_file).get_server_logger()


def get_client_logger(config_file="config.ini"):
    """获取客户端日志器"""
    return get_logger_config(config_file).get_client_logger()


def get_locker_logger(config_file="config.ini"):
    """获取电磁锁日志器"""
    return get_logger_config(config_file).get_locker_logger()


def get_camera_logger(config_file="config.ini"):
    """获取摄像头日志器"""
    return get_logger_config(config_file).get_camera_logger()


def get_general_logger(config_file="config.ini"):
    """获取通用日志器"""
    return get_logger_config(config_file).get_general_logger()


def setup_root_logger(config_file="config.ini"):
    """设置根日志器"""
    return get_logger_config(config_file).setup_root_logger()


# 使用示例
if __name__ == "__main__":
    # 测试日志配置
    print("=== 日志配置测试 ===")
    
    # 创建日志配置
    logger_config = LoggerConfig()
    
    # 获取不同类型的日志器
    server_logger = logger_config.get_server_logger()
    client_logger = logger_config.get_client_logger()
    locker_logger = logger_config.get_locker_logger()
    camera_logger = logger_config.get_camera_logger()
    general_logger = logger_config.get_general_logger()
    
    # 测试日志输出
    server_logger.info("这是服务器日志测试")
    client_logger.info("这是客户端日志测试")
    locker_logger.info("这是电磁锁日志测试")
    camera_logger.info("这是摄像头日志测试")
    general_logger.info("这是通用日志测试")
    
    # 测试不同级别的日志
    server_logger.debug("这是调试信息")
    server_logger.warning("这是警告信息")
    server_logger.error("这是错误信息")
    
    print("日志配置测试完成，请检查log目录中的日志文件")
